home *** CD-ROM | disk | FTP | other *** search
/ Amiga Games Extra 1996 September / Amiga Games Extra CD-ROM 9-1996.iso / userbox / publicdomain / vim-4.2 / src / mark.c < prev    next >
C/C++ Source or Header  |  1996-06-09  |  23KB  |  948 lines
  1. /* vi:set ts=4 sw=4:
  2.  *
  3.  * VIM - Vi IMproved        by Bram Moolenaar
  4.  *
  5.  * Do ":help uganda"  in Vim to read copying and usage conditions.
  6.  * Do ":help credits" in Vim to see a list of people who contributed.
  7.  */
  8.  
  9. /*
  10.  * mark.c: functions for setting marks and jumping to them
  11.  */
  12.  
  13. #include "vim.h"
  14. #include "globals.h"
  15. #include "proto.h"
  16. #include "option.h"
  17.  
  18. /*
  19.  * This file contains routines to maintain and manipulate marks.
  20.  */
  21.  
  22. /*
  23.  * If a named file mark's lnum is non-zero, it is valid.
  24.  * If a named file mark's fnum is non-zero, it is for an existing buffer,
  25.  * otherwise it is from .viminfo and namedfm_names[n] is the file name.
  26.  * There are marks 'A - 'Z (set by user) and '0 to '9 (set when writing
  27.  * viminfo).
  28.  */
  29. #define EXTRA_MARKS    10                                    /* marks 0-9 */
  30. static struct filemark namedfm[NMARKS + EXTRA_MARKS];    /* marks with file nr */
  31. static char_u *namedfm_names[NMARKS + EXTRA_MARKS];        /* name for namedfm[] */
  32.  
  33. static void show_one_mark __ARGS((int, char_u *, FPOS *, char_u *));
  34. static void cleanup_jumplist __ARGS((void));
  35. #ifdef VIMINFO
  36. static int removable __ARGS((char_u *name));
  37. #endif
  38.  
  39. /*
  40.  * setmark(c) - set named mark 'c' at current cursor position
  41.  *
  42.  * Returns OK on success, FAIL if no room for mark or bad name given.
  43.  */
  44.     int
  45. setmark(c)
  46.     int            c;
  47. {
  48.     int         i;
  49.  
  50.     if (c > 'z')            /* some islower() and isupper() cannot handle
  51.                                 characters above 127 */
  52.         return FAIL;
  53.     if (islower(c))
  54.     {
  55.         i = c - 'a';
  56.         curbuf->b_namedm[i] = curwin->w_cursor;
  57.         return OK;
  58.     }
  59.     if (isupper(c))
  60.     {
  61.         i = c - 'A';
  62.         namedfm[i].mark = curwin->w_cursor;
  63.         namedfm[i].fnum = curbuf->b_fnum;
  64.         return OK;
  65.     }
  66.     return FAIL;
  67. }
  68.  
  69. /*
  70.  * setpcmark() - set the previous context mark to the current position
  71.  *                 and add it to the jump list
  72.  */
  73.     void
  74. setpcmark()
  75. {
  76.     int i;
  77. #ifdef ROTATE
  78.     struct filemark tempmark;
  79. #endif
  80.  
  81.     /* for :global the mark is set only once */
  82.     if (global_busy)
  83.         return;
  84.  
  85.     curwin->w_prev_pcmark = curwin->w_pcmark;
  86.     curwin->w_pcmark = curwin->w_cursor;
  87.  
  88. #ifdef ROTATE
  89.     /*
  90.      * If last used entry is not at the top, put it at the top by rotating
  91.      * the stack until it is (the newer entries will be at the bottom).
  92.      * Keep one entry (the last used one) at the top.
  93.      */
  94.     if (curwin->w_jumplistidx < curwin->w_jumplistlen)
  95.         ++curwin->w_jumplistidx;
  96.     while (curwin->w_jumplistidx < curwin->w_jumplistlen)
  97.     {
  98.         tempmark = curwin->w_jumplist[curwin->w_jumplistlen - 1];
  99.         for (i = curwin->w_jumplistlen - 1; i > 0; --i)
  100.             curwin->w_jumplist[i] = curwin->w_jumplist[i - 1];
  101.         curwin->w_jumplist[0] = tempmark;
  102.         ++curwin->w_jumplistidx;
  103.     }
  104. #endif
  105.  
  106.     /* If jumplist is full: remove oldest entry */
  107.     if (++curwin->w_jumplistlen > JUMPLISTSIZE)
  108.     {
  109.         curwin->w_jumplistlen = JUMPLISTSIZE;
  110.         for (i = 1; i < JUMPLISTSIZE; ++i)
  111.             curwin->w_jumplist[i - 1] = curwin->w_jumplist[i];
  112.     }
  113.     curwin->w_jumplistidx = curwin->w_jumplistlen - 1;
  114.  
  115. #ifdef ARCHIE
  116.     /* Workaround for a bug in gcc 2.4.5 R2 on the Archimedes
  117.      * Should be fixed in 2.5.x.
  118.      */
  119.     curwin->w_jumplist[curwin->w_jumplistidx].mark.ptr = curwin->w_pcmark.ptr;
  120.     curwin->w_jumplist[curwin->w_jumplistidx].mark.col = curwin->w_pcmark.col;
  121. #else
  122.     curwin->w_jumplist[curwin->w_jumplistidx].mark = curwin->w_pcmark;
  123. #endif
  124.     curwin->w_jumplist[curwin->w_jumplistidx].fnum = curbuf->b_fnum;
  125.     ++curwin->w_jumplistidx;
  126.  
  127.     /* remove any duplicates, from the new entry or from previous deletes */
  128.     cleanup_jumplist();
  129. }
  130.  
  131. /*
  132.  * checkpcmark() - To change context, call setpcmark(), then move the current
  133.  *                   position to where ever, then call checkpcmark().  This
  134.  *                   ensures that the previous context will only be changed if
  135.  *                   the cursor moved to a different line. -- webb.
  136.  *                   If pcmark was deleted (with "dG") the previous mark is
  137.  *                   restored.
  138.  */
  139.     void
  140. checkpcmark()
  141. {
  142.     if (curwin->w_prev_pcmark.lnum != 0 &&
  143.             (equal(curwin->w_pcmark, curwin->w_cursor) ||
  144.             curwin->w_pcmark.lnum == 0))
  145.     {
  146.         curwin->w_pcmark = curwin->w_prev_pcmark;
  147.         curwin->w_prev_pcmark.lnum = 0;            /* Show it has been checked */
  148.     }
  149. }
  150.  
  151. /*
  152.  * move "count" positions in the jump list (count may be negative)
  153.  */
  154.     FPOS *
  155. movemark(count)
  156.     int count;
  157. {
  158.     FPOS        *pos;
  159.  
  160.     cleanup_jumplist();
  161.  
  162.     if (curwin->w_jumplistlen == 0)            /* nothing to jump to */
  163.         return (FPOS *)NULL;
  164.  
  165.     if (curwin->w_jumplistidx + count < 0 ||
  166.                         curwin->w_jumplistidx + count >= curwin->w_jumplistlen)
  167.         return (FPOS *)NULL;
  168.  
  169.     /*
  170.      * if first CTRL-O or CTRL-I command after a jump, add cursor position to
  171.      * list.  Careful: If there are duplicates (CTRL-O immidiately after
  172.      * starting Vim on a file), another entry may have been removed.
  173.      */
  174.     if (curwin->w_jumplistidx == curwin->w_jumplistlen)
  175.     {
  176.         setpcmark();
  177.         --curwin->w_jumplistidx;        /* skip the new entry */
  178.         if (curwin->w_jumplistidx + count < 0)
  179.             return (FPOS *)NULL;
  180.     }
  181.  
  182.     curwin->w_jumplistidx += count;
  183.                                                 /* jump to other file */
  184.     if (curwin->w_jumplist[curwin->w_jumplistidx].fnum != curbuf->b_fnum)
  185.     {
  186.         if (buflist_getfile(curwin->w_jumplist[curwin->w_jumplistidx].fnum,
  187.                           curwin->w_jumplist[curwin->w_jumplistidx].mark.lnum,
  188.                                                                0) == FAIL)
  189.             return (FPOS *)NULL;
  190.         curwin->w_cursor.col =
  191.                            curwin->w_jumplist[curwin->w_jumplistidx].mark.col;
  192.         pos = (FPOS *)-1;
  193.     }
  194.     else
  195.         pos = &(curwin->w_jumplist[curwin->w_jumplistidx].mark);
  196.     return pos;
  197. }
  198.  
  199. /*
  200.  * getmark(c) - find mark for char 'c'
  201.  *
  202.  * Return pointer to FPOS if found (caller needs to check lnum!)
  203.  *        NULL if there is no mark called 'c'.
  204.  *        -1 if mark is in other file (only if changefile is TRUE)
  205.  */
  206.     FPOS *
  207. getmark(c, changefile)
  208.     int            c;
  209.     int            changefile;
  210. {
  211.     FPOS            *posp;
  212.     FPOS            *startp, *endp;
  213.     static    FPOS    pos_copy;
  214.     int                len;
  215.     char_u            *p;
  216.  
  217.     posp = NULL;
  218.     if (c > '~')                        /* check for islower()/isupper() */
  219.         ;
  220.     else if (c == '\'' || c == '`')        /* previous context mark */
  221.     {
  222.         pos_copy = curwin->w_pcmark;    /* need to make a copy because */
  223.         posp = &pos_copy;                /*   w_pcmark may be changed soon */
  224.     }
  225.     else if (c == '"')                    /* to pos when leaving buffer */
  226.         posp = &(curbuf->b_last_cursor);
  227.     else if (c == '[')                    /* to start of previous operator */
  228.         posp = &(curbuf->b_op_start);
  229.     else if (c == ']')                    /* to end of previous operator */
  230.         posp = &(curbuf->b_op_end);
  231.     else if (c == '<' || c == '>')        /* start/end of visual area */
  232.     {
  233.         if (VIsual_active)
  234.             startp = &VIsual_save;
  235.         else
  236.             startp = &VIsual;
  237.         endp = &VIsual_end;
  238.         if ((c == '<') == lt(*startp, *endp))
  239.             posp = startp;
  240.         else
  241.             posp = endp;
  242.     }
  243.     else if (islower(c))                /* normal named mark */
  244.         posp = &(curbuf->b_namedm[c - 'a']);
  245.     else if (isupper(c) || isdigit(c))    /* named file mark */
  246.     {
  247.         if (isdigit(c))
  248.             c = c - '0' + NMARKS;
  249.         else
  250.             c -= 'A';
  251.         posp = &(namedfm[c].mark);
  252.  
  253.         if (namedfm[c].fnum == 0 && namedfm_names[c] != NULL)
  254.         {
  255.             /*
  256.              * First expand "~/" in the file name to the home directory.
  257.              * Try to find the shortname by comparing the fullname with the
  258.              * current directory.
  259.              */
  260.             expand_env(namedfm_names[c], NameBuff, MAXPATHL);
  261.             mch_dirname(IObuff, IOSIZE);
  262.             len = STRLEN(IObuff);
  263.             if (fnamencmp(IObuff, NameBuff, len) == 0)
  264.             {
  265.                 p = NameBuff + len;
  266.                 if (ispathsep(*p))
  267.                     ++p;
  268.             }
  269.             else
  270.                 p = NULL;
  271.                                 /* buflist_new will call fmarks_check_names() */
  272.             (void)buflist_new(NameBuff, p, (linenr_t)1, FALSE);
  273.         }
  274.  
  275.         if (namedfm[c].fnum != curbuf->b_fnum)        /* mark is in other file */
  276.         {
  277.             if (namedfm[c].mark.lnum != 0 && changefile && namedfm[c].fnum)
  278.             {
  279.                 if (buflist_getfile(namedfm[c].fnum,
  280.                                     namedfm[c].mark.lnum, GETF_SETMARK) == OK)
  281.                 {
  282.                     curwin->w_cursor.col = namedfm[c].mark.col;
  283.                     return (FPOS *)-1;
  284.                 }
  285.             }
  286.             posp = &pos_copy;            /* mark exists, but is not valid in
  287.                                             current buffer */
  288.             pos_copy.lnum = 0;
  289.         }
  290.     }
  291.     return posp;
  292. }
  293.  
  294. /*
  295.  * Check all file marks for a name that matches the file name in buf.
  296.  * May replace the name with an fnum.
  297.  */
  298.     void
  299. fmarks_check_names(buf)
  300.     BUF     *buf;
  301. {
  302.     char_u        *name;
  303.     int            i;
  304.  
  305.     if (buf->b_filename == NULL)
  306.         return;
  307.  
  308.     name = home_replace_save(buf, buf->b_filename);
  309.     if (name == NULL)
  310.         return;
  311.  
  312.     for (i = 0; i < NMARKS + EXTRA_MARKS; ++i)
  313.     {
  314.         if (namedfm[i].fnum == 0 && namedfm_names[i] != NULL &&
  315.                                         fnamecmp(name, namedfm_names[i]) == 0)
  316.         {
  317.             namedfm[i].fnum = buf->b_fnum;
  318.             vim_free(namedfm_names[i]);
  319.             namedfm_names[i] = NULL;
  320.         }
  321.     }
  322.     vim_free(name);
  323. }
  324.  
  325. /*
  326.  * Check a if a position from a mark is valid.
  327.  * Give and error message and return FAIL if not.
  328.  */
  329.     int
  330. check_mark(pos)
  331.     FPOS    *pos;
  332. {
  333.     if (pos == NULL)
  334.     {
  335.         emsg(e_umark);
  336.         return FAIL;
  337.     }
  338.     if (pos->lnum == 0)
  339.     {
  340.         emsg(e_marknotset);
  341.         return FAIL;
  342.     }
  343.     if (pos->lnum > curbuf->b_ml.ml_line_count)
  344.     {
  345.         emsg(e_markinval);
  346.         return FAIL;
  347.     }
  348.     return OK;
  349. }
  350.  
  351. /*
  352.  * clrallmarks() - clear all marks in the buffer 'buf'
  353.  *
  354.  * Used mainly when trashing the entire buffer during ":e" type commands
  355.  */
  356.     void
  357. clrallmarks(buf)
  358.     BUF        *buf;
  359. {
  360.     static int             i = -1;
  361.  
  362.     if (i == -1)        /* first call ever: initialize */
  363.         for (i = 0; i < NMARKS + 1; i++)
  364.         {
  365.             namedfm[i].mark.lnum = 0;
  366.             namedfm_names[i] = NULL;
  367.         }
  368.  
  369.     for (i = 0; i < NMARKS; i++)
  370.         buf->b_namedm[i].lnum = 0;
  371.     buf->b_op_start.lnum = 0;        /* start/end op mark cleared */
  372.     buf->b_op_end.lnum = 0;
  373. }
  374.  
  375. /*
  376.  * get name of file from a filemark
  377.  * Careful: buflist_nr2name returns NameBuff.
  378.  */
  379.     char_u *
  380. fm_getname(fmark)
  381.     struct filemark *fmark;
  382. {
  383.     if (fmark->fnum != curbuf->b_fnum)                /* not current file */
  384.         return buflist_nr2name(fmark->fnum, FALSE, TRUE);
  385.     return (char_u *)"-current-";
  386. }
  387.  
  388. /*
  389.  * print the marks
  390.  */
  391.     void
  392. do_marks(arg)
  393.     char_u        *arg;
  394. {
  395.     int            i;
  396.     char_u        *name;
  397.  
  398.     if (arg != NULL && *arg == NUL)
  399.         arg = NULL;
  400.  
  401.     show_one_mark('\'', arg, &curwin->w_pcmark, NULL);
  402.     for (i = 0; i < NMARKS; ++i)
  403.         show_one_mark(i + 'a', arg, &curbuf->b_namedm[i], NULL);
  404.     for (i = 0; i < NMARKS + EXTRA_MARKS; ++i)
  405.     {
  406.         name = namedfm[i].fnum == 0 ? namedfm_names[i] :
  407.                                                       fm_getname(&namedfm[i]);
  408.         if (name != NULL)
  409.             show_one_mark(i >= NMARKS ? i - NMARKS + '0' : i + 'A',
  410.                                                  arg, &namedfm[i].mark, name);
  411.     }
  412.     show_one_mark('"', arg, &curbuf->b_last_cursor, NULL);
  413.     show_one_mark('[', arg, &curbuf->b_op_start, NULL);
  414.     show_one_mark(']', arg, &curbuf->b_op_end, NULL);
  415.     show_one_mark('<', arg, &VIsual, NULL);
  416.     show_one_mark('>', arg, &VIsual_end, NULL);
  417.     show_one_mark(-1, arg, NULL, NULL);
  418. }
  419.  
  420.     static void
  421. show_one_mark(c, arg, p, name)
  422.     int        c;
  423.     char_u    *arg;
  424.     FPOS    *p;
  425.     char_u    *name;
  426. {
  427.     static int        did_title = FALSE;
  428.  
  429.     if (c == -1)                            /* finish up */
  430.     {
  431.         if (did_title)
  432.             did_title = FALSE;
  433.         else
  434.         {
  435.             if (arg == NULL)
  436.                 MSG("No marks set");
  437.             else
  438.                 EMSG2("No marks matching \"%s\"", arg);
  439.         }
  440.     }
  441.     /* don't output anything if 'q' typed at --more-- prompt */
  442.     else if (!got_int && (arg == NULL || vim_strchr(arg, c) != NULL) &&
  443.                                                                  p->lnum != 0)
  444.     {
  445.         if (!did_title)
  446.         {
  447.             set_highlight('t');                /* Highlight title */
  448.             start_highlight();
  449.             MSG_OUTSTR("\nmark line  col file");
  450.             stop_highlight();
  451.             did_title = TRUE;
  452.         }
  453.         msg_outchar('\n');
  454.         if (!got_int)
  455.         {
  456.             sprintf((char *)IObuff, " %c %5ld  %3d  ", c, p->lnum, p->col);
  457.             if (name != NULL)
  458.                 STRCAT(IObuff, name);
  459.             msg_outtrans(IObuff);
  460.         }
  461.         flushbuf();                    /* show one line at a time */
  462.     }
  463. }
  464.  
  465. /*
  466.  * print the jumplist
  467.  */
  468.     void
  469. do_jumps()
  470. {
  471.     int            i;
  472.     char_u        *name;
  473.  
  474.     cleanup_jumplist();
  475.     set_highlight('t');        /* Highlight title */
  476.     start_highlight();
  477.     MSG_OUTSTR("\n jump line  file");
  478.     stop_highlight();
  479.     for (i = 0; i < curwin->w_jumplistlen; ++i)
  480.     {
  481.         if (curwin->w_jumplist[i].mark.lnum != 0)
  482.         {
  483.             name = fm_getname(&curwin->w_jumplist[i]);
  484.             if (name == NULL)        /* file name not available */
  485.                 continue;
  486.  
  487.             msg_outchar('\n');
  488.             sprintf((char *)IObuff, "%c %2d %5ld  %s",
  489.                 i == curwin->w_jumplistidx ? '>' : ' ',
  490.                 i + 1,
  491.                 curwin->w_jumplist[i].mark.lnum,
  492.                 name);
  493.             msg_outtrans(IObuff);
  494.         }
  495.         flushbuf();
  496.     }
  497.     if (curwin->w_jumplistidx == curwin->w_jumplistlen)
  498.         MSG_OUTSTR("\n>");
  499. }
  500.  
  501. /*
  502.  * adjust marks between line1 and line2 (inclusive) to move 'amount' lines
  503.  * If 'amount' is MAXLNUM the mark is made invalid.
  504.  * If 'amount_after' is non-zero adjust marks after line 2.
  505.  */
  506.  
  507. #define one_adjust(add) \
  508.     { \
  509.         lp = add; \
  510.         if (*lp >= line1 && *lp <= line2) \
  511.         { \
  512.             if (amount == MAXLNUM) \
  513.                 *lp = 0; \
  514.             else \
  515.                 *lp += amount; \
  516.         } \
  517.         else if (amount_after && *lp > line2) \
  518.             *lp += amount_after; \
  519.     }
  520.  
  521. /* don't delete the line, just put at first deleted line */
  522. #define one_adjust_nodel(add) \
  523.     { \
  524.         lp = add; \
  525.         if (*lp >= line1 && *lp <= line2) \
  526.         { \
  527.             if (amount == MAXLNUM) \
  528.                 *lp = line1; \
  529.             else \
  530.                 *lp += amount; \
  531.         } \
  532.         else if (amount_after && *lp > line2) \
  533.             *lp += amount_after; \
  534.     }
  535.  
  536.     void
  537. mark_adjust(line1, line2, amount, amount_after)
  538.     linenr_t    line1;
  539.     linenr_t    line2;
  540.     long        amount;
  541.     long        amount_after;
  542. {
  543.     int            i;
  544.     int            fnum = curbuf->b_fnum;
  545.     linenr_t    *lp;
  546.     WIN            *win;
  547.  
  548.     if (line2 < line1 && amount_after == 0L)        /* nothing to do */
  549.         return;
  550.  
  551. /* named marks, lower case and upper case */
  552.     for (i = 0; i < NMARKS; i++)
  553.     {
  554.         one_adjust(&(curbuf->b_namedm[i].lnum));
  555.         if (namedfm[i].fnum == fnum)
  556.             one_adjust(&(namedfm[i].mark.lnum));
  557.     }
  558.     for (i = NMARKS; i < NMARKS + EXTRA_MARKS; i++)
  559.     {
  560.         if (namedfm[i].fnum == fnum)
  561.             one_adjust(&(namedfm[i].mark.lnum));
  562.     }
  563.  
  564. /* previous context mark */
  565.     one_adjust(&(curwin->w_pcmark.lnum));
  566.  
  567. /* previous pcmark */
  568.     one_adjust(&(curwin->w_prev_pcmark.lnum));
  569.  
  570. /* Visual area */
  571.     one_adjust_nodel(&(VIsual.lnum));
  572.     one_adjust_nodel(&(VIsual_end.lnum));
  573.  
  574. /* marks in the tag stack */
  575.     for (i = 0; i < curwin->w_tagstacklen; i++)
  576.         if (curwin->w_tagstack[i].fmark.fnum == fnum)
  577.             one_adjust_nodel(&(curwin->w_tagstack[i].fmark.mark.lnum));
  578.  
  579. /* quickfix marks */
  580.     qf_mark_adjust(line1, line2, amount, amount_after);
  581.  
  582. /* jumplist marks */
  583.     for (win = firstwin; win != NULL; win = win->w_next)
  584.     {
  585.         /*
  586.          * When deleting lines, this may create duplicate marks in the
  587.          * jumplist. They will be removed later.
  588.          */
  589.         for (i = 0; i < win->w_jumplistlen; ++i)
  590.             if (win->w_jumplist[i].fnum == fnum)
  591.                 one_adjust_nodel(&(win->w_jumplist[i].mark.lnum));
  592.         /*
  593.          * also adjust the line at the top of the window and the cursor
  594.          * position for windows with the same buffer.
  595.          */
  596.         if (win != curwin && win->w_buffer == curbuf)
  597.         {
  598.             if (win->w_topline >= line1 && win->w_topline <= line2)
  599.             {
  600.                 if (amount == MAXLNUM)        /* topline is deleted */
  601.                 {
  602.                     if (line1 <= 1)
  603.                         win->w_topline = 1;
  604.                     else
  605.                         win->w_topline = line1 - 1;
  606.                 }
  607.                 else                    /* keep topline on the same line */
  608.                     win->w_topline += amount;
  609.             }
  610.             else if (amount_after && win->w_topline > line2)
  611.                 win->w_topline += amount_after;
  612.             if (win->w_cursor.lnum >= line1 && win->w_cursor.lnum <= line2)
  613.             {
  614.                 if (amount == MAXLNUM)        /* line with cursor is deleted */
  615.                 {
  616.                     if (line1 <= 1)
  617.                         win->w_cursor.lnum = 1;
  618.                     else
  619.                         win->w_cursor.lnum = line1 - 1;
  620.                     win->w_cursor.col = 0;
  621.                 }
  622.                 else                    /* keep cursor on the same line */
  623.                     win->w_cursor.lnum += amount;
  624.             }
  625.             else if (amount_after && win->w_cursor.lnum > line2)
  626.                 win->w_cursor.lnum += amount_after;
  627.         }
  628.     }
  629. }
  630.  
  631. /*
  632.  * When deleting lines, this may create duplicate marks in the
  633.  * jumplist. They will be removed here for the current window.
  634.  */
  635.     static void
  636. cleanup_jumplist()
  637. {
  638.     int        i;
  639.     int        from, to;
  640.  
  641.     to = 0;
  642.     for (from = 0; from < curwin->w_jumplistlen; ++from)
  643.     {
  644.         if (curwin->w_jumplistidx == from)
  645.             curwin->w_jumplistidx = to;
  646.         for (i = from + 1; i < curwin->w_jumplistlen; ++i)
  647.             if (curwin->w_jumplist[i].fnum == curwin->w_jumplist[from].fnum &&
  648.                 curwin->w_jumplist[i].mark.lnum ==
  649.                                            curwin->w_jumplist[from].mark.lnum)
  650.                 break;
  651.         if (i >= curwin->w_jumplistlen)        /* no duplicate */
  652.             curwin->w_jumplist[to++] = curwin->w_jumplist[from];
  653.     }
  654.     if (curwin->w_jumplistidx == curwin->w_jumplistlen)
  655.         curwin->w_jumplistidx = to;
  656.     curwin->w_jumplistlen = to;
  657. }
  658.  
  659.     void
  660. set_last_cursor(win)
  661.     WIN        *win;
  662. {
  663.     win->w_buffer->b_last_cursor = win->w_cursor;
  664. }
  665.  
  666. #ifdef VIMINFO
  667.     int
  668. read_viminfo_filemark(line, fp, force)
  669.     char_u    *line;
  670.     FILE    *fp;
  671.     int        force;
  672. {
  673.     int        idx;
  674.     char_u    *str;
  675.  
  676.     /* We only get here (hopefully) if line[0] == '\'' */
  677.     str = line + 1;
  678.     if (*str > 127 || (!isdigit(*str) && !isupper(*str)))
  679.         EMSG2("viminfo: Illegal file mark name in line %s", line);
  680.     else
  681.     {
  682.         if (isdigit(*str))
  683.             idx = *str - '0' + NMARKS;
  684.         else
  685.             idx = *str - 'A';
  686.         if (namedfm[idx].mark.lnum == 0 || force)
  687.         {
  688.             str = skipwhite(str + 1);
  689.             namedfm[idx].mark.lnum = getdigits(&str);
  690.             str = skipwhite(str);
  691.             namedfm[idx].mark.col = getdigits(&str);
  692.             str = skipwhite(str);
  693.             viminfo_readstring(line);
  694.             namedfm_names[idx] = strsave(str);
  695.         }
  696.     }
  697.     return vim_fgets(line, LSIZE, fp);
  698. }
  699.  
  700.     void
  701. write_viminfo_filemarks(fp)
  702.     FILE    *fp;
  703. {
  704.     int        i;
  705.     char_u    *name;
  706.  
  707.     if (get_viminfo_parameter('\'') == 0)
  708.         return;
  709.  
  710.     fprintf(fp, "\n# File marks:\n");
  711.  
  712.     /*
  713.      * Find a mark that is the same file and position as the cursor.
  714.      * That one, or else the last one is deleted.
  715.      * Move '0 to '1, '1 to '2, etc. until the matching one or '9
  716.      * Set '0 mark to current cursor position.
  717.      */
  718.     if (curbuf->b_filename != NULL && !removable(curbuf->b_filename))
  719.     {
  720.         name = buflist_nr2name(curbuf->b_fnum, TRUE, FALSE);
  721.         for (i = NMARKS; i < NMARKS + EXTRA_MARKS - 1; ++i)
  722.             if (namedfm[i].mark.lnum == curwin->w_cursor.lnum &&
  723.                             (namedfm_names[i] == NULL ?
  724.                                            namedfm[i].fnum == curbuf->b_fnum :
  725.                                           STRCMP(name, namedfm_names[i]) == 0))
  726.                 break;
  727.  
  728.         vim_free(namedfm_names[i]);
  729.         for ( ; i > NMARKS; --i)
  730.         {
  731.             namedfm[i] = namedfm[i - 1];
  732.             namedfm_names[i] = namedfm_names[i - 1];
  733.         }
  734.         namedfm[NMARKS].mark = curwin->w_cursor;
  735.         namedfm[NMARKS].fnum = curbuf->b_fnum;
  736.         namedfm_names[NMARKS] = NULL;
  737.     }
  738.  
  739.     for (i = 0; i < NMARKS + EXTRA_MARKS; i++)
  740.     {
  741.         if (namedfm[i].mark.lnum == 0)            /* not set */
  742.             continue;
  743.  
  744.         if (namedfm[i].fnum)                    /* there is a buffer */
  745.             name = buflist_nr2name(namedfm[i].fnum, TRUE, FALSE);
  746.         else
  747.             name = namedfm_names[i];            /* use name from .viminfo */
  748.         if (name == NULL)
  749.             continue;
  750.  
  751.         fprintf(fp, "'%c  %ld  %ld  %s\n",
  752.                     i < NMARKS ? i + 'A' : i - NMARKS + '0',
  753.                     (long)namedfm[i].mark.lnum,
  754.                     (long)namedfm[i].mark.col,
  755.                     name);
  756.     }
  757. }
  758.  
  759. /*
  760.  * Return TRUE if "name" is on removable media (depending on 'viminfo').
  761.  */
  762.     static int
  763. removable(name)
  764.     char_u    *name;
  765. {
  766.     char_u    *p;
  767.     char_u    part[51];
  768.     int        retval = FALSE;
  769.  
  770.     name = home_replace_save(NULL, name);
  771.     if (name != NULL)
  772.     {
  773.         for (p = p_viminfo; *p; )
  774.         {
  775.             copy_option_part(&p, part, 51, ", ");
  776.             if (part[0] == 'r' && vim_strnicmp(part + 1, name,
  777.                     (size_t)STRLEN(part + 1)) == 0)
  778.             {
  779.                 retval = TRUE;
  780.                 break;
  781.             }
  782.         }
  783.         vim_free(name);
  784.     }
  785.     return retval;
  786. }
  787.  
  788. /*
  789.  * Write all the named marks for all buffers.
  790.  * Return the number of buffers for which marks have been written.
  791.  */
  792.     int
  793. write_viminfo_marks(fp_out)
  794.     FILE    *fp_out;
  795. {
  796.     int        count;
  797.     BUF        *buf;
  798.     WIN        *win;
  799.     int        is_mark_set;
  800.     int        i;
  801.  
  802.     /*
  803.      * Set b_last_cursor for the all buffers that have a window.
  804.      */
  805.     for (win = firstwin; win != NULL; win = win->w_next)
  806.         set_last_cursor(win);
  807.  
  808.     fprintf(fp_out, "\n# History of marks within files (newest to oldest):\n");
  809.     count = 0;
  810.     for (buf = firstbuf; buf != NULL; buf = buf->b_next)
  811.     {
  812.         /*
  813.          * Only write something if buffer has been loaded and at least one
  814.          * mark is set.
  815.          */
  816.         if (buf->b_marks_read)
  817.         {
  818.             if (buf->b_last_cursor.lnum != 0)
  819.                 is_mark_set = TRUE;
  820.             else
  821.             {
  822.                 is_mark_set = FALSE;
  823.                 for (i = 0; i < NMARKS; i++)
  824.                     if (buf->b_namedm[i].lnum != 0)
  825.                     {
  826.                         is_mark_set = TRUE;
  827.                         break;
  828.                     }
  829.             }
  830.             if (is_mark_set && buf->b_filename != NULL &&
  831.                  buf->b_filename[0] != NUL && !removable(buf->b_filename))
  832.             {
  833.                 home_replace(NULL, buf->b_filename, IObuff, IOSIZE);
  834.                 fprintf(fp_out, "\n> %s\n", (char *)IObuff);
  835.                 if (buf->b_last_cursor.lnum != 0)
  836.                     fprintf(fp_out, "\t\"\t%ld\t%d\n",
  837.                             buf->b_last_cursor.lnum, buf->b_last_cursor.col);
  838.                 for (i = 0; i < NMARKS; i++)
  839.                     if (buf->b_namedm[i].lnum != 0)
  840.                         fprintf(fp_out, "\t%c\t%ld\t%d\n", 'a' + i,
  841.                                 buf->b_namedm[i].lnum, buf->b_namedm[i].col);
  842.                 count++;
  843.             }
  844.         }
  845.     }
  846.  
  847.     return count;
  848. }
  849.  
  850. /*
  851.  * Handle marks in the viminfo file:
  852.  * fp_out == NULL    read marks for current buffer only
  853.  * fp_out != NULL    copy marks for buffers not in buffer list
  854.  */
  855.     void
  856. copy_viminfo_marks(line, fp_in, fp_out, count, eof)
  857.     char_u        *line;
  858.     FILE        *fp_in;
  859.     FILE        *fp_out;
  860.     int            count;
  861.     int            eof;
  862. {
  863.     BUF            *buf;
  864.     int            num_marked_files;
  865.     char_u        save_char;
  866.     int            load_marks;
  867.     int            copy_marks_out;
  868.     char_u        *str;
  869.     int            i;
  870.     char_u        *p;
  871.  
  872.     num_marked_files = get_viminfo_parameter('\'');
  873.     while (!eof && (count < num_marked_files || fp_out == NULL))
  874.     {
  875.         if (line[0] != '>')
  876.         {
  877.             if (line[0] != '\n' && line[0] != '\r' && line[0] != '#')
  878.                 EMSG2("viminfo: Illegal starting char in line %s", line);
  879.             eof = vim_fgets(line, LSIZE, fp_in);
  880.             continue;            /* Skip this dud line */
  881.         }
  882.  
  883.         /*
  884.          * Find filename, set str to start.
  885.          * Ignore leading and trailing white space.
  886.          */
  887.         str = skipwhite(line + 1);
  888.         p = str + STRLEN(str);
  889.         while (p != str && (*p == NUL || vim_isspace(*p)))
  890.             p--;
  891.         if (*p)
  892.             p++;
  893.         save_char = *p;
  894.         *p = NUL;
  895.  
  896.         /*
  897.          * If fp_out == NULL, load marks for current buffer.
  898.          * If fp_out != NULL, copy marks for buffers not in buflist.
  899.          */
  900.         load_marks = copy_marks_out = FALSE;
  901.         if (fp_out == NULL)
  902.         {
  903.             if (curbuf->b_filename != NULL &&
  904.                              fullpathcmp(str, curbuf->b_filename) == FPC_SAME)
  905.                 load_marks = TRUE;
  906.         }
  907.         else /* fp_out != NULL */
  908.         {
  909.             /* This is slow if there are many buffers!! */
  910.             for (buf = firstbuf; buf != NULL; buf = buf->b_next)
  911.                 if (buf->b_filename != NULL &&
  912.                                 fullpathcmp(str, buf->b_filename) == FPC_SAME)
  913.                     break;
  914.  
  915.             /*
  916.              * copy marks if the buffer has not been loaded
  917.              */
  918.             if (buf == NULL || !buf->b_marks_read)
  919.             {
  920.                 copy_marks_out = TRUE;
  921.                 *p = save_char;
  922.                 fputs("\n", fp_out);
  923.                 fputs((char *)line, fp_out);
  924.                 count++;
  925.             }
  926.         }
  927.         while (!(eof = vim_fgets(line, LSIZE, fp_in)) && line[0] == TAB)
  928.         {
  929.             if (load_marks)
  930.             {
  931.                 if (line[1] == '"')
  932.                     sscanf((char *)line + 2, "%ld %d",
  933.                             &curbuf->b_last_cursor.lnum,
  934.                             &curbuf->b_last_cursor.col);
  935.                 else if ((i = line[1] - 'a') >= 0 && i < NMARKS)
  936.                     sscanf((char *)line + 2, "%ld %d",
  937.                             &curbuf->b_namedm[i].lnum,
  938.                             &curbuf->b_namedm[i].col);
  939.             }
  940.             else if (copy_marks_out)
  941.                 fputs((char *)line, fp_out);
  942.         }
  943.         if (load_marks)
  944.             return;
  945.     }
  946. }
  947. #endif /* VIMINFO */
  948.